package com.esun.rabbit2.viewer.mainact.lotteryhallact.shiyixuanwu.rabbittrunk;

import java.io.UnsupportedEncodingException;

/**
 * @ClassName: ByteUtils
 * @Description: TODO(字符串分割、编码等工具)
 * @author Miko baoz@500wan.com
 * @date 2011-1-13 下午09:26:04
 * 
 */
public class ByteUtils {

    /**
     * @Title: removeByte0
     * @Description: TODO(从字节数组中过滤掉 byte 0 缺省字符串)
     * @param str
     *            需要过滤的 字符串
     * @return str 过滤后的String类型字符串
     */
    public String removeByte0(String str) {

        byte[] bTmp = new byte[1];
        String strTemp = bytesToString(bTmp, 0, 1);

        if (str.contains(strTemp)) {
            str = str.substring(0, str.indexOf(strTemp));
        }

        return str;
    }

    /**
     * 从字节数组中指定的位置读取一个Short类型的数据。
     * 
     * @param b
     *            字节数组
     * @param pos
     *            指定的开始位置
     * @return 一个Short类型的数据
     */

    public short bytes2Short(byte[] b, int pos) {
        int val = 0;
        val = b[pos + 1] & 0xFF; // 多字节数据，低8位在前面的字节。
        val = val << 8;
        val |= b[pos] & 0xFF;
        return (short) val;
    }

    /**
     * 从字节数组中指定的位置读取一个Integer类型的数据。
     * 
     * @param b
     *            字节数组
     * @param pos
     *            指定的开始位置
     * @return 一个Integer类型的数据
     */
    public int bytes2Integer(byte[] b, int pos) {
        int val = 0;
        val = b[pos + 3] & 0xff; // 多字节数据，低8位在前面的字节。
        val <<= 8;
        val |= b[pos + 2] & 0xff;
        val <<= 8;
        val |= b[pos + 1] & 0xff;
        val <<= 8;
        val |= b[pos] & 0xff;
        return val;
    }

    /**
     * 转换一个int为byte数组
     * 
     * @param byt
     *            目标byte数组
     * @param position
     *            byte标志位
     * @param val
     *            需要转换的字符串
     * @author Miko
     */
    public static void integer2Bytes(byte[] byt, int position, int val) {
        byt[position + 3] = (byte) (val >>> 24 & 0xff); // 低位在前
        byt[position + 2] = (byte) (val >>> 16 & 0xff);
        byt[position + 1] = (byte) (val >>> 8 & 0xff);
        byt[position] = (byte) (val & 0xff);
    }

    /**
     * 转换一个shor字符串为byte数组
     * 
     * @param byt
     *            目标byte数组
     * @param position
     *            byte标志位
     * @param val
     *            需要转换的字符串
     * @author Miko
     */
    public static void shortToBytes(byte[] byt, int position, short val) {
        byt[position + 1] = (byte) (val >>> 8 & 0xff);
        byt[position] = (byte) (val & 0xff);
    }

    /**
     * 转换一个String字符串为byte数组
     * 
     * @param str
     *            需要转换的字符串
     * @param byt
     *            目标byte数组
     * @param position
     *            byte标志位
     * @author Miko
     */
    public static void StringToBytes(String str, byte[] byt, int position) {

        byte[] byteTemp;
        try {

            byteTemp = str.getBytes("UTF-8");
            System.arraycopy(byteTemp, 0, byt, position, byteTemp.length);

        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 转换一个二进制数组为字符串
     * 
     * @param bytes
     *            需要转换的二进制数组
     * @return 转换后的字符串
     */
    public static String bytesToString(byte[] bytes) {
        return bytesToString(bytes, 0, bytes.length);
    }

    /**
     * 转换一个二进制数组中指定长度数据为字符串
     * 
     * @param bytes
     *            需要转换的二进制数组
     * @param off
     *            开始转换的起始位置
     * @param len
     *            转换的长度
     * @return 转换后的字符串
     */
    public static String bytesToString(byte[] bytes, int off, int len) {
        // System.out.println(System.getProperty("microedition.encoding"));
        String ret = null;
        if (bytes != null) {
            try {
                ret = new String(bytes, off, len, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                ret = new String(bytes, off, len);// +e.getMessage();
                e.printStackTrace();
            }
        }
        return ret;
    }

}
